Termination w.r.t. Q proof of TRS/AProVELiveness6.3.trs

Termination w.r.t. Q of the following Term Rewriting System could not be shown:

Q restricted rewrite system:
The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.

↳ QTRS

  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.

Using Dependency Pairs [1,13] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

TOP₁(rec₁(up₁(x))) -> REC₁(x)
CHECK₁(no₁(x)) -> CHECK₁(x)
REC₁(bot) -> SENT₁(bot)
REC₁(rec₁(x)) -> SENT₁(rec₁(x))
TOP₁(sent₁(up₁(x))) -> CHECK₁(rec₁(x))
CHECK₁(rec₁(x)) -> CHECK₁(x)
REC₁(up₁(x)) -> REC₁(x)
TOP₁(no₁(up₁(x))) -> REC₁(x)
TOP₁(sent₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))
REC₁(no₁(x)) -> SENT₁(rec₁(x))
CHECK₁(sent₁(x)) -> SENT₁(check₁(x))
CHECK₁(rec₁(x)) -> REC₁(check₁(x))
TOP₁(no₁(up₁(x))) -> CHECK₁(rec₁(x))
CHECK₁(no₁(x)) -> NO₁(check₁(x))
REC₁(sent₁(x)) -> SENT₁(rec₁(x))
CHECK₁(up₁(x)) -> CHECK₁(x)
TOP₁(sent₁(up₁(x))) -> REC₁(x)
TOP₁(rec₁(up₁(x))) -> CHECK₁(rec₁(x))
TOP₁(no₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))
REC₁(no₁(x)) -> REC₁(x)
NO₁(up₁(x)) -> NO₁(x)
SENT₁(up₁(x)) -> SENT₁(x)
TOP₁(rec₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))
REC₁(sent₁(x)) -> REC₁(x)
CHECK₁(sent₁(x)) -> CHECK₁(x)

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

TOP₁(rec₁(up₁(x))) -> REC₁(x)
CHECK₁(no₁(x)) -> CHECK₁(x)
REC₁(bot) -> SENT₁(bot)
REC₁(rec₁(x)) -> SENT₁(rec₁(x))
TOP₁(sent₁(up₁(x))) -> CHECK₁(rec₁(x))
CHECK₁(rec₁(x)) -> CHECK₁(x)
REC₁(up₁(x)) -> REC₁(x)
TOP₁(no₁(up₁(x))) -> REC₁(x)
TOP₁(sent₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))
REC₁(no₁(x)) -> SENT₁(rec₁(x))
CHECK₁(sent₁(x)) -> SENT₁(check₁(x))
CHECK₁(rec₁(x)) -> REC₁(check₁(x))
TOP₁(no₁(up₁(x))) -> CHECK₁(rec₁(x))
CHECK₁(no₁(x)) -> NO₁(check₁(x))
REC₁(sent₁(x)) -> SENT₁(rec₁(x))
CHECK₁(up₁(x)) -> CHECK₁(x)
TOP₁(sent₁(up₁(x))) -> REC₁(x)
TOP₁(rec₁(up₁(x))) -> CHECK₁(rec₁(x))
TOP₁(no₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))
REC₁(no₁(x)) -> REC₁(x)
NO₁(up₁(x)) -> NO₁(x)
SENT₁(up₁(x)) -> SENT₁(x)
TOP₁(rec₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))
REC₁(sent₁(x)) -> REC₁(x)
CHECK₁(sent₁(x)) -> CHECK₁(x)

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 5 SCCs with 13 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

NO₁(up₁(x)) -> NO₁(x)

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

NO₁(up₁(x)) -> NO₁(x)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(NO₁(x₁)) = 2·x₁
POL(up₁(x₁)) = 1 + 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SENT₁(up₁(x)) -> SENT₁(x)

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

SENT₁(up₁(x)) -> SENT₁(x)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(SENT₁(x₁)) = 2·x₁
POL(up₁(x₁)) = 1 + 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

REC₁(up₁(x)) -> REC₁(x)
REC₁(no₁(x)) -> REC₁(x)
REC₁(sent₁(x)) -> REC₁(x)

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

REC₁(sent₁(x)) -> REC₁(x)

The remaining pairs can at least be oriented weakly.

REC₁(up₁(x)) -> REC₁(x)
REC₁(no₁(x)) -> REC₁(x)

Used ordering: Polynomial interpretation [21]:

POL(REC₁(x₁)) = 2·x₁
POL(no₁(x₁)) = 2·x₁
POL(sent₁(x₁)) = 2 + 2·x₁
POL(up₁(x₁)) = 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

REC₁(up₁(x)) -> REC₁(x)
REC₁(no₁(x)) -> REC₁(x)

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

REC₁(no₁(x)) -> REC₁(x)

The remaining pairs can at least be oriented weakly.

REC₁(up₁(x)) -> REC₁(x)

Used ordering: Polynomial interpretation [21]:

POL(REC₁(x₁)) = 2·x₁
POL(no₁(x₁)) = 2 + 2·x₁
POL(up₁(x₁)) = 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

REC₁(up₁(x)) -> REC₁(x)

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

REC₁(up₁(x)) -> REC₁(x)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(REC₁(x₁)) = 2·x₁
POL(up₁(x₁)) = 1 + 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

CHECK₁(no₁(x)) -> CHECK₁(x)
CHECK₁(up₁(x)) -> CHECK₁(x)
CHECK₁(sent₁(x)) -> CHECK₁(x)
CHECK₁(rec₁(x)) -> CHECK₁(x)

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

CHECK₁(rec₁(x)) -> CHECK₁(x)

The remaining pairs can at least be oriented weakly.

CHECK₁(no₁(x)) -> CHECK₁(x)
CHECK₁(up₁(x)) -> CHECK₁(x)
CHECK₁(sent₁(x)) -> CHECK₁(x)

Used ordering: Polynomial interpretation [21]:

POL(CHECK₁(x₁)) = 2·x₁
POL(no₁(x₁)) = 2·x₁
POL(rec₁(x₁)) = 2 + 2·x₁
POL(sent₁(x₁)) = 2·x₁
POL(up₁(x₁)) = 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

CHECK₁(no₁(x)) -> CHECK₁(x)
CHECK₁(up₁(x)) -> CHECK₁(x)
CHECK₁(sent₁(x)) -> CHECK₁(x)

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

CHECK₁(sent₁(x)) -> CHECK₁(x)

The remaining pairs can at least be oriented weakly.

CHECK₁(no₁(x)) -> CHECK₁(x)
CHECK₁(up₁(x)) -> CHECK₁(x)

Used ordering: Polynomial interpretation [21]:

POL(CHECK₁(x₁)) = 2·x₁
POL(no₁(x₁)) = 2·x₁
POL(sent₁(x₁)) = 2 + 2·x₁
POL(up₁(x₁)) = 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

CHECK₁(no₁(x)) -> CHECK₁(x)
CHECK₁(up₁(x)) -> CHECK₁(x)

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

CHECK₁(up₁(x)) -> CHECK₁(x)

The remaining pairs can at least be oriented weakly.

CHECK₁(no₁(x)) -> CHECK₁(x)

Used ordering: Polynomial interpretation [21]:

POL(CHECK₁(x₁)) = 2·x₁
POL(no₁(x₁)) = 2·x₁
POL(up₁(x₁)) = 2 + 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

CHECK₁(no₁(x)) -> CHECK₁(x)

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

CHECK₁(no₁(x)) -> CHECK₁(x)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(CHECK₁(x₁)) = 2·x₁
POL(no₁(x₁)) = 1 + 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ PisEmptyProof

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

TOP₁(no₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))
TOP₁(sent₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))
TOP₁(rec₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

TOP₁(no₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))

The remaining pairs can at least be oriented weakly.

TOP₁(sent₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))
TOP₁(rec₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))

Used ordering: Polynomial interpretation [21]:

POL(TOP₁(x₁)) = 2·x₁
POL(bot) = 0
POL(check₁(x₁)) = x₁
POL(no₁(x₁)) = 2·x₁
POL(rec₁(x₁)) = 1
POL(sent₁(x₁)) = x₁
POL(up₁(x₁)) = 1

The following usable rules [14] were oriented:

check₁(no₁(x)) -> no₁(check₁(x))
rec₁(bot) -> up₁(sent₁(bot))
check₁(sent₁(x)) -> sent₁(check₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
check₁(no₁(x)) -> no₁(x)
rec₁(up₁(x)) -> up₁(rec₁(x))
check₁(up₁(x)) -> up₁(check₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

TOP₁(sent₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))
TOP₁(rec₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

TOP₁(rec₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))

The remaining pairs can at least be oriented weakly.

TOP₁(sent₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))

Used ordering: Polynomial interpretation [21]:

POL(TOP₁(x₁)) = 2·x₁
POL(bot) = 0
POL(check₁(x₁)) = x₁
POL(no₁(x₁)) = 2·x₁
POL(rec₁(x₁)) = 1 + x₁
POL(sent₁(x₁)) = x₁
POL(up₁(x₁)) = 1 + x₁

The following usable rules [14] were oriented:

check₁(no₁(x)) -> no₁(check₁(x))
rec₁(bot) -> up₁(sent₁(bot))
check₁(sent₁(x)) -> sent₁(check₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
check₁(no₁(x)) -> no₁(x)
rec₁(up₁(x)) -> up₁(rec₁(x))
check₁(up₁(x)) -> up₁(check₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

TOP₁(sent₁(up₁(x))) -> TOP₁(check₁(rec₁(x)))

The TRS R consists of the following rules:

rec₁(rec₁(x)) -> sent₁(rec₁(x))
rec₁(sent₁(x)) -> sent₁(rec₁(x))
rec₁(no₁(x)) -> sent₁(rec₁(x))
rec₁(bot) -> up₁(sent₁(bot))
rec₁(up₁(x)) -> up₁(rec₁(x))
sent₁(up₁(x)) -> up₁(sent₁(x))
no₁(up₁(x)) -> up₁(no₁(x))
top₁(rec₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(sent₁(up₁(x))) -> top₁(check₁(rec₁(x)))
top₁(no₁(up₁(x))) -> top₁(check₁(rec₁(x)))
check₁(up₁(x)) -> up₁(check₁(x))
check₁(sent₁(x)) -> sent₁(check₁(x))
check₁(rec₁(x)) -> rec₁(check₁(x))
check₁(no₁(x)) -> no₁(check₁(x))
check₁(no₁(x)) -> no₁(x)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.